package com.atlin.project.temp;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CipherDemo {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            try {
                printMenu();
                int choice = scanner.nextInt();
                scanner.nextLine(); // Consume newline

                if (choice == 1) {
                    System.out.print("请输入需要加密的文本：");
                    String text = scanner.nextLine();
                    System.out.print("请输入偏移量：");
                    int shift = scanner.nextInt();
                    scanner.nextLine(); // Consume newline
                    String encryptedText = caesarCipher(text, shift);
                    System.out.println("加密后的文本：" + encryptedText);
                } else if (choice == 2) {
                    System.out.print("请输入需要加密的文本：");
                    String text = scanner.nextLine();
                    String encryptedText = substitutionCipher(text);
                    System.out.println("加密后的文本：" + encryptedText);
                } else if (choice == 3) {
                    System.out.print("请输入需要加密的文本：");
                    String text = scanner.nextLine();
                    System.out.print("请输入偏移量：");
                    int shift = scanner.nextInt();
                    scanner.nextLine(); // Consume newline
                    String encryptedText = shiftCipher(text, shift);
                    System.out.println("加密后的文本：" + encryptedText);
                } else if (choice == 4) {
                    System.out.println("感谢使用，再见！");
                    break;
                } else {
                    System.out.println("无效的选择，请重新输入。");
                }
            } catch (Exception e) {
                System.out.println("发生错误，请重新输入。");
                scanner.nextLine(); // Consume the invalid input
            }
        }
        scanner.close();
    }
    

    private static void printMenu() {
        System.out.println("========================================");
        System.out.println("          欢迎使用密码加密程序          ");
        System.out.println("========================================");
        System.out.println("1. 凯撒密码加密");
        System.out.println("2. 替换密码加密");
        System.out.println("3. 移位密码加密");
        System.out.println("4. 退出");
        System.out.println("========================================");
        System.out.print("请输入你的选择（1-4）：");
    }

    // 定义一个方法，用于实现凯撒密码加密
    private static String caesarCipher(String text, int shift) {
        // 创建一个StringBuilder对象，用于存储加密后的字符串
        StringBuilder result = new StringBuilder();
        // 遍历输入字符串的每个字符
        for (char charInText : text.toCharArray()) {
            // 判断字符是否为字母
            if (Character.isLetter(charInText)) {
                // 判断字母是否为大写字母
                int shiftAmount = Character.isUpperCase(charInText) ? 'A' : 'a';
                // 将字母转换为加密后的字符，并添加到结果字符串中
                result.append((char) ((charInText - shiftAmount + shift) % 26 + shiftAmount));
            } else {
                // 如果字符不是字母，则直接添加到结果字符串中
                result.append(charInText);
            }
        }
        // 返回加密后的字符串
        return result.toString();
    }

    // 对给定的文本进行替换加密
    private static String substitutionCipher(String text) {
        Map<Character, Character> substitutionMap = new HashMap<>();
        for (int i = 0; i < 26; i++) {
            char original = (char) ('a' + i);
            char substitute = (char) ('m' + i % 26);
            substitutionMap.put(original, substitute);
            substitutionMap.put(Character.toUpperCase(original), Character.toUpperCase(substitute));
        }
        // 创建一个StringBuilder对象，用于存储加密后的文本
        StringBuilder result = new StringBuilder();
        // 遍历文本中的每一个字符
        for (char charInText : text.toCharArray()) {
            // 将字符替换为对应的加密字符，如果不存在对应的加密字符，则保持原字符不变
            result.append(substitutionMap.getOrDefault(charInText, charInText));
        }
        // 返回加密后的文本
        return result.toString();
    }

    // 移位密码算法
    private static String shiftCipher(String text, int shift) {
        // 创建一个StringBuilder对象，用于存储结果
        StringBuilder result = new StringBuilder();
        // 遍历输入的字符串
        for (char charInText : text.toCharArray()) {
            // 判断字符是否为字母
            if (Character.isLetter(charInText)) {
                // 判断字母是否为大写
                int shiftAmount = Character.isUpperCase(charInText) ? 'A' : 'a';
                // 计算移位后的字符
                result.append((char) ((charInText - shiftAmount - shift + 26) % 26 + shiftAmount));
            } else {
                // 如果不是字母，则直接添加到结果中
                result.append(charInText);
            }
        }
        // 返回结果
        return result.toString();
    }
}
